Coverage remained the same at 100.0% when pulling 1985ad2 on gcla:master into 57af0be on go-test:master.

It's a good idea and would make a good change for v1.1. There's a couple things I'd change wrt the design, etc.

1. s/MakeComparer/New Comparer/ as "NewX" is more idiomatic Go
2. Struct fields don't need to be pointers, i.e. FloatPrecision int is sufficient. Out of curiosity, why are they pointers?
3. Keeping Equal(a, b interface{}) []string is good, really want to do this. I'd simplify and hide the default:

var defaultComparer = Comparer{
    // default values
}

Might have more feedback after seeing changes, if you decided to make them (and merge latest to fix the merge conflicts).

Hi - thanks for considering the PR :-)

I'll update the branch so it's based off of latest and resubmit. I'll rename MakeComparer to NewComparer, and hide the default, as you suggest.

For point (2) - it seemed to me that the current implementation made FloatPrecision, MaxDepth, etc a dynamic part of the interface in that each call to Equal() would use their current values in computing the result. For example, if the user ran

deep.MaxDepth = 5
Equal(a, b)

the result might be different from

deep.MaxDepth = 10
Equal(a, b)

To preserve that behavior, I made the Comparer struct use pointers for these fields, and by default I made the pointers point to these exported variables. So even though, with this PR, Equal() defers to defaultComparer.Equal(), these package-level variables continue to have the same effect on the computation.

I'll definitely simplify things if you think that's the best way to go.

Sorry for jumping in, but I was also toying around with this idea for fun.
How about something like this? It's backwards compatible without introducing new public types (besides the variadic options). I have this implemented if you're interested.

deep.CompareUnexportedFields = false
deep.FloatPrecision = 1

s1 := s{a: 0.0078125}  // 1/128
s2 := s{a: 0.00390625} // 1/256

deep.Equal(s1, s2) // nil
deep.Equal(s1, s2, deep.WithCompareUnexportedFields()) // nil
deep.Equal(s1, s2, deep.WithCompareUnexportedFields(), deep.WithFloatPrecision(3)) // "a: 0.0078125 != 0.00390625"

Hi @flga - your patch would definitely work for my needs, and I'd be happy to just switch over to your implementation :-)